home *** CD-ROM | disk | FTP | other *** search
/ Aminet 15 / Aminet 15 - Nov 1996.iso / Aminet / comm / bbs / s342q16.lha / util_lib.c < prev    next >
C/C++ Source or Header  |  1996-08-31  |  17KB  |  565 lines
  1. #include "ctdl.h"
  2. #include "stdio.h"
  3. #include "string.h"
  4. #include "stdlib.h"
  5. CONFIG    cfg;                   /* A buncha variables           */
  6. LogTable  *logTab;               /* RAM index of pippuls         */
  7. NetTable  *netTab;               /* RAM index of nodes           */
  8. rTable    *roomTab;              /* RAM index of rooms           */
  9. EVENT     *EventTab = NULL;
  10. char             *indexTable = "ctdlTabl.sys";
  11. struct floor     *FloorTab;
  12. int              TopFloor;
  13. extern char *R_W_ANY;
  14.  
  15. logBuffer logBuf;                       /* Log buffer of a person       */
  16. logBuffer logTmp;                       /* Useful global buffer         */
  17. int       thisLog;                      /* entry currently in logBuf    */
  18. FILE      *logfl;                       /* log file descriptor          */
  19. static struct
  20.   {
  21.   int checkMark;                      /* rudimentary integrity        */
  22.   int cfgSize;                        /* sizeof cfg                   */
  23.   int logTSize;                       /* logtab size                  */
  24.   int endMark;                        /* another integrity check      */
  25.  
  26.   }  integrity;
  27. extern char *R_W_ANY;
  28. void *FindServes();
  29. SListBase Serves =
  30.   {
  31.   NULL, FindServes, NULL, free, NULL
  32.  
  33.   };
  34.  
  35. #define CHKM    7       /* major release        */
  36. #define ENDM    8
  37.  
  38. void getLog(logBuffer *lBuf, int n)
  39. {
  40.     long int s, r;
  41.  
  42.     if (lBuf == &logBuf)   thisLog      = n;
  43.  
  44.     r = LB_TOTAL_SIZE;                  /* To get away from overflows   */
  45.     s = n * r;                          /* This should be offset        */
  46.  
  47.     fseek(logfl, s, 0);
  48.  
  49.     if (fread((char *)lBuf, LB_SIZE, 1, logfl) != 1)
  50.       {
  51.       printf("getLog: Could not read User Log entry: %d(pos = $ld, size=%ld)\n",n, s, r);
  52.       printf("        position = %ld, size of read = %ld\n",s,r);
  53.       }
  54.     else
  55.       {
  56.       crypte(lBuf, LB_SIZE, n*3);           /* decode buffer    */
  57.       if (fread((char *)lBuf->lbgen, GEN_BULK, 1, logfl) != 1)
  58.         {
  59.         printf("getLog: read fail reading general data(pos = %ld, size=%ld)\n",(s+r), (long)GEN_BULK);
  60.         };
  61.       if (fread((char *)lBuf->lbMail, MAIL_BULK, 1, logfl) != 1)
  62.         {
  63.         printf("getLog: read fail reading mail data(pos = %ld, size = %ld)\n", (s+r+GEN_BULK), (long)MAIL_BULK);
  64.         };
  65.       };
  66.   }
  67. /************************************************************************/
  68. /*      readSysTab() restores state of system from CTDLTABL.SYS         */
  69. /*      returns:        TRUE on success, else FALSE                     */
  70. /*      MS-DOS fun: Here's the map --                                   */
  71. /*      Word 1 == sizeof cfg                                            */
  72. /*      Word 2 == sizeof logTab                                         */
  73. /*      Word 3 == sizeof roomTab                                        */
  74. /*      Word 4 -- thru x == cfg contents                                */
  75. /*      x -- y == logTab                                                */
  76. /*      y -- z == roomTab                                               */
  77. /*      z -- a == netTab                                                */
  78. /*      EOF                                                             */
  79. /************************************************************************/
  80. char readSysTab(char kill, char showMsg)
  81.   {
  82.   FILE *fd;
  83.   extern char *READ_ANY;
  84.   int         rover;
  85.   long        bytes;
  86.   SYS_FILE    name;
  87.   char        caller;
  88.   label       temp;
  89.   caller = cfg.weAre;
  90.   if ((fd = fopen(indexTable, READ_ANY)) == NULL)
  91.     {
  92.     printf("readSysTab:  open failed on %s\n",indexTable);
  93.     perror("readSysTab");
  94.     poserr("readSysTab");
  95.     return(FALSE);
  96.  
  97.     }
  98.   if (fread((char *)&integrity, sizeof integrity, 1, fd) != 1)
  99.     {
  100.     printf("readSysTab: Unable to read the integrity data\n");
  101.     perror("readSysTab");
  102.     poserr("readSysTab");
  103.     return FALSE;
  104.  
  105.     }
  106.   if (     integrity.checkMark != CHKM ||
  107.   integrity.endMark != ENDM ||
  108.   integrity.cfgSize != sizeof cfg)
  109.     {
  110.     printf("readSysTab: Integrity mismatch.  Old ctdltabl.sys?\n");
  111.     return(FALSE);
  112.  
  113.     }
  114.   if (!common_read(&cfg, (sizeof cfg), 1, fd, showMsg))
  115.   return FALSE;
  116.   /* Allocations for dynamic parameters */
  117.   logTab = (LogTable *) GetDynamic(integrity.logTSize);
  118.   roomTab = (rTable *) GetDynamic(MAXROOMS * (sizeof (*roomTab)));
  119.   if (cfg.netSize)
  120.   netTab = (NetTable *) GetDynamic(sizeof (*netTab) * cfg.netSize);
  121.   else
  122.   netTab = NULL;
  123.   if (cfg.EvNumber)
  124.   EventTab  = (EVENT *)
  125.   GetDynamic(sizeof (*EventTab) * cfg.EvNumber);
  126.   /* "- 1" is kludge */
  127.   if (integrity.logTSize != sizeof (*logTab) * cfg.MAXLOGTAB)
  128.     {
  129.     printf("readSysTab: Integrity check: size mismatch on logtable\n");
  130.     printf("            Integrity size is %ld\n",integrity.logTSize);
  131.     printf("            computed  size is %ld\n",sizeof (*logTab) * cfg.MAXLOGTAB);
  132.     return(FALSE);
  133.  
  134.     }
  135.   if (!common_read(logTab, integrity.logTSize, 1, fd, showMsg))
  136.     {
  137.     printf("readSysTab: Unable to load logTab\n");
  138.     return(FALSE);
  139.     };
  140.   if (!common_read(roomTab, (sizeof (*roomTab)) * MAXROOMS, 1, fd, showMsg))
  141.     {
  142.     printf("readSysTab: Unable to load roomTab\n");
  143.     return(FALSE);
  144.     };
  145.   if (cfg.netSize)
  146.     {
  147.     for (rover = 0; rover < cfg.netSize; rover++)
  148.       {
  149.       if (!common_read(&netTab[rover], NT_SIZE, 1, fd, showMsg))
  150.         {
  151.         printf("readSysTab: Unable to load netTab[%d](size = %ld)\n",rover, (long)NT_SIZE );
  152.         return(FALSE);
  153.         };
  154.       netTab[rover].netTRooms =
  155.       (SharedRoom *) GetDynamic(SR_BULK);
  156.       if (!common_read(netTab[rover].netTRooms, SR_BULK, 1, fd, showMsg))
  157.         {
  158.         printf("readSysTab: Unable to load netTab[%d]/netTRooms(size = %ld)\n",rover, (long)NT_SIZE );
  159.         return(FALSE);
  160.         };
  161.  
  162.       }
  163.  
  164.     }
  165.   if (cfg.EvNumber)
  166.     {
  167.     if (!common_read(EventTab, (sizeof(*EventTab) * cfg.EvNumber), 1, fd,
  168.     showMsg))
  169.       {
  170.       printf("readSysTab: Unable to load EventTab(size = %ld)\n",(sizeof(*EventTab) * cfg.EvNumber) );
  171.       return(FALSE);
  172.       };
  173.  
  174.     }
  175.   for (rover = 0; rover < cfg.DomainHandlers; rover++)
  176.     {
  177.     if (!common_read(temp, NAMESIZE, 1, fd, showMsg))
  178.       {
  179.       printf("readSysTab: Unable to load DomainHandles[%d](size = %ld)\n",rover, (long)NAMESIZE);
  180.       return(FALSE);
  181.       };
  182.     AddData(&Serves, strdup(temp), NULL, FALSE);
  183.  
  184.     }
  185.   fclose(fd);
  186.   makeSysName(name, "ctdlflr.sys", &cfg.floorArea);
  187.   if ((fd = fopen(name, R_W_ANY)) == NULL)
  188.     {
  189.     if (caller != CONFIGUR)
  190.       {
  191.       printf("readSysTab:  open failed on %s\n",name);
  192.       perror("readSysTab");
  193.       poserr("readSysTab");
  194.       return(FALSE);
  195.       };
  196.     }
  197.   else
  198.     {
  199.     totalBytes(&bytes, fd);
  200.     FloorTab = (struct floor *) GetDynamic((int) bytes);
  201.     if (fread((char *)FloorTab, (int) bytes, 1, fd) != 1)
  202.       {
  203.       printf("problem reading floor tab");
  204.       printf("readSysTab: problem reading floor table(%s)\n",name);
  205.       perror("readSysTab");
  206.       poserr("readSysTab");
  207.       fclose(fd);
  208.       if (caller != CONFIGUR) return FALSE;
  209.  
  210.       }
  211.     else
  212.       {
  213.       fclose(fd);
  214.       TopFloor = (int) bytes/sizeof(*FloorTab);
  215.  
  216.       }
  217.  
  218.     }
  219.   crypte(cfg.sysPassword, sizeof cfg.sysPassword, 0);
  220.   return(TRUE);
  221.  
  222.   }
  223. /************************************************************************/
  224. /*      common_read() reads in from file the important stuff            */
  225. /*      returns:        TRUE on success, else FALSE                     */
  226. /************************************************************************/
  227. static int common_read(void *block, int size, int elements, FILE *fd,
  228. char showMsg)
  229.   {
  230.   if (size == 0) return TRUE;
  231.   if (fread((char *)block, size, elements, fd) != 1)
  232.     {
  233.     printf("common_read: Unable to read data from file(%d records, %d size\n",elements, size);
  234.     perror("readSysTab");
  235.     poserr("readSysTab");
  236.     return FALSE;
  237.  
  238.     };
  239.   return TRUE;
  240.  
  241.   }
  242.  
  243. void *special_GetDynamic(unsigned size, char *file, int line)
  244.   {
  245.   void *temp;
  246.   if (size == 0) return NULL; /* Simplify code                */
  247.   if ((temp = (void *)malloc(size)) == NULL)
  248.     {
  249.     printf("Request for %u bytes failed.\n", size);
  250.     exit(100);
  251.     }
  252.   memset(temp, 0, size);
  253.   return temp;
  254.  
  255.   }
  256.  
  257. void crypte(void *buf, unsigned len, unsigned seed)
  258.   {
  259.   static AN_UNSIGNED *b;      /* Make this static for speed (I guess),*/
  260.   static  int c, s;           /* since register variables not around  */
  261.   if( cfg.cryptSeed == 0)return;
  262.   seed        = (seed + cfg.cryptSeed) & 0xFF;
  263.   b           = (AN_UNSIGNED *)buf;
  264.   c           = len;
  265.   s           = seed;
  266.   for (;  c;  c--)
  267.     {
  268.     *b++   ^= s;
  269.     s       = (s + CRYPTADD)  &  0xFF;
  270.  
  271.     }
  272.  
  273.   }
  274.  
  275. UNS_16 hash(char *str)
  276. {
  277.     UNS_16  h, shift;
  278.  
  279.     for (h=shift=0;  *str;  shift=(shift+1)&7, str++) {
  280.         h ^= (toUpper(*str)) << shift;
  281.     }
  282.     return h;
  283. }
  284. /************************************************************************/
  285. /*      FindServes() find the server function                           */
  286. /************************************************************************/
  287. static void *FindServes(char *name, char *target)
  288.   {
  289.   return (strCmpU(name, target) == SAMESTRING) ? name : NULL;
  290.  
  291.   }
  292. static FILE *fd;
  293. /************************************************************************/
  294. /*      writeSysTab() saves state of system in CTDLTABL.SYS             */
  295. /*      returns:        TRUE on success, else ERROR                     */
  296. /*      See readSysTab() to see what the CTDLTABL.SYS map looks like.   */
  297. /************************************************************************/
  298. int writeSysTab()
  299.   {
  300.   void WriteServers();
  301.   extern char   *WRITE_ANY;
  302.   int           rover;
  303.   if ((fd = fopen(indexTable, WRITE_ANY)) == NULL)
  304.     {
  305.     printf("writeSysTab: problem writing %s\n",indexTable);
  306.     perror("writeSysTab");
  307.     poserr("writeSysTab");
  308.     return(ERROR);
  309.     };
  310.  
  311.   /* Write out some key stuff so we can detect bizarreness: */
  312.   integrity.checkMark = CHKM;
  313.   integrity.endMark = ENDM;
  314.   integrity.cfgSize = sizeof cfg;
  315.   integrity.logTSize = sizeof (*logTab) * cfg.MAXLOGTAB;
  316.   if( 1 != fwrite((char *)&integrity, (sizeof integrity), 1, fd) )
  317.     {
  318.     printf("writeSysTab: problem writing integrity data\n");
  319.     perror("writeSysTab");
  320.     poserr("writeSysTab");
  321.     return(ERROR);
  322.     };
  323.  
  324.   crypte(cfg.sysPassword, sizeof cfg.sysPassword, 0);
  325.   if( 1 != fwrite((char *)&cfg, (sizeof cfg), 1, fd) )
  326.     {
  327.     printf("writeSysTab: problem writing configuration data\n");
  328.     perror("writeSysTab");
  329.     poserr("writeSysTab");
  330.     return(ERROR);
  331.     };
  332.  
  333.   crypte(cfg.sysPassword, sizeof cfg.sysPassword, 0);
  334.   if( 1 != fwrite((char *)logTab, (sizeof(*logTab) * cfg.MAXLOGTAB), 1, fd))
  335.     {
  336.     printf("writeSysTab: problem writing User Log table\n");
  337.     perror("writeSysTab");
  338.     poserr("writeSysTab");
  339.     return(ERROR);
  340.     };
  341.  
  342.   if( 1 != fwrite((char *)roomTab, (sizeof (*roomTab)) * MAXROOMS, 1, fd))
  343.     {
  344.     printf("writeSysTab: problem writing room table\n");
  345.     perror("writeSysTab");
  346.     poserr("writeSysTab");
  347.     return(ERROR);
  348.     };
  349.  
  350.   for (rover = 0; rover < cfg.netSize; rover++)
  351.     {
  352.     if( 1 != fwrite((char *)&netTab[rover], NT_SIZE, 1, fd))
  353.       {
  354.       printf("writeSysTab: problem writing Net Table[%d]\n",rover);
  355.       perror("writeSysTab");
  356.       poserr("writeSysTab");
  357.       return(ERROR);
  358.       };
  359.  
  360.     if( 1 != fwrite((char *)netTab[rover].netTRooms, SR_BULK, 1, fd))
  361.       {
  362.       printf("writeSysTab: problem writing Net Table/Room[%d]\n",rover);
  363.       perror("writeSysTab");
  364.       poserr("writeSysTab");
  365.       return(ERROR);
  366.       };
  367.  
  368.     };
  369.   if (cfg.EvNumber)
  370.   if( 1 != fwrite((char *)EventTab, (sizeof(*EventTab) * cfg.EvNumber), 1, fd))
  371.     {
  372.     printf("writeSysTab: problem writing Event Table\n");
  373.     perror("writeSysTab");
  374.     poserr("writeSysTab");
  375.     return(ERROR);
  376.     };
  377.  
  378.   RunList(&Serves, WriteServers);
  379.   fclose(fd);
  380.   return(TRUE);
  381.  
  382.   }
  383. /************************************************************************/
  384. /*      WriteServers() writes a server out to ctdltabl.sys              */
  385. /************************************************************************/
  386. static void WriteServers(char *name)
  387.   {
  388.   if( 1 != fwrite((char *)name, NAMESIZE, 1, fd))
  389.     {
  390.     printf("WriteServers: problem writing server data\n");
  391.     perror("writeServers");
  392.     poserr("writeServers");
  393.     };
  394.   }
  395.  
  396. void putLog(logBuffer *lBuf, int n)
  397. {
  398.     long int s, r;
  399.  
  400.     r = LB_TOTAL_SIZE;
  401.     s = n * r;
  402.  
  403.     crypte(lBuf, LB_SIZE, n*3);         /* encode buffer        */
  404.  
  405.     if (cfg.weAre != CONFIGUR)        /* No need if configuring         */
  406.         fseek(logfl, s, 0);
  407.  
  408.     if (fwrite((char *)lBuf, LB_SIZE, 1, logfl) != 1)
  409.        {
  410.        printf("putLog: failed to write user log entry %d(pos = %ld, size=%ld)\n",n,s,r);
  411.        perror("putLog");
  412.        poserr("putLog");
  413.        }
  414.  
  415.     if (fwrite((char *)lBuf->lbgen, GEN_BULK, 1, logfl) != 1)
  416.         {
  417.         printf("putLog: write fail on general data(pos = %ld, size=%ld)\n",(s+r), (long)GEN_BULK);
  418.         };
  419.  
  420.     if (fwrite((char *)lBuf->lbMail, MAIL_BULK, 1, logfl) != 1)
  421.         {
  422.         printf("putLog: write fail on mail data(pos = %ld, size = %ld)\n", (s+r+GEN_BULK), (long)MAIL_BULK);
  423.         };
  424.  
  425.     crypte(lBuf, LB_SIZE, n*3);         /* encode buffer        */
  426.  
  427.     fflush(logfl);
  428. }
  429. /************************************************************************/
  430. /*      openFile() opens one of the .sys files.                         */
  431. /************************************************************************/
  432. void openFile(char *filename, FILE **fd)
  433.   {
  434.   /* We use fopen here rather than safeopen for link reasons */
  435.   if ((*fd = fopen(filename, R_W_ANY)) == NULL)
  436.     {
  437.     printf("?no %s, cannot open it", filename);
  438.     exit(SYSOP_EXIT);
  439.  
  440.     }
  441.  
  442.   }
  443. /************************************************************************/
  444. /*      PersonExists() check to see if the given name is valid for mail */
  445. /************************************************************************/
  446. int PersonExists(char *name)
  447. {
  448.     int result;
  449.  
  450.     result = findPerson(name, &logTmp);
  451.     if (result != ERROR) strCpy(name, logTmp.lbname);
  452.     return result;
  453. }
  454. /************************************************************************/
  455. /*      findPerson() loads log record for named person.                 */
  456. /*      RETURNS: ERROR if not found, else log record #                  */
  457. /************************************************************************/
  458. int findPerson(char *name, logBuffer *lBuf)
  459. {
  460.     int  h, i, foundIt, logNo;
  461.  
  462.     if (strLen(name) == 0) return ERROR;
  463.  
  464.     if (strCmpU(name, "Citadel") != SAMESTRING) {
  465.         h   = hash(name);
  466.         for (foundIt = i = 0;  i < cfg.MAXLOGTAB && !foundIt;  i++) {
  467.             if (logTab[i].ltnmhash == h) {
  468.                 getLog(lBuf, logNo = logTab[i].ltlogSlot);
  469.                 if (lBuf->lbflags.L_INUSE &&
  470.                         strCmpU(name, lBuf->lbname) == SAMESTRING) {
  471.                     foundIt = TRUE;
  472.                 }
  473.             }
  474.         }
  475.     }
  476.     else foundIt = FALSE;
  477.     if (!foundIt)    return ERROR;
  478.     else             return logNo;
  479. }
  480.  
  481. /*
  482. * lbyte()
  483. *
  484. * This function finds the 0 byte of a string, returns pointer to it...
  485. */
  486. char *lbyte(char *l)
  487.   {
  488.   while (*l) l++;
  489.   return l;
  490.  
  491.   }
  492. /*
  493. * NormStr()
  494. *
  495. * This function Deletes leading trailing blanks etc.
  496. */
  497. void NormStr(char *s)
  498.   {
  499.   char *pc;
  500.   pc = s;
  501.   /* find end of string   */
  502.   while (*pc)
  503.     {
  504.     if (*pc < ' ')   *pc = ' ';   /* zap tabs etc... */
  505.     pc++;
  506.  
  507.     }
  508.   /* no trailing spaces: */
  509.   while (pc>s  &&  isSpace(*(pc-1))) pc--;
  510.   *pc = '\0';
  511.   /* no leading spaces: */
  512.   while (*s == ' ')
  513.     {
  514.     for (pc=s;  *pc;  pc++)    *pc = *(pc+1);
  515.  
  516.     }
  517.   /* no double blanks */
  518.   for (;  *s;)
  519.     {
  520.     if (*s == ' '   &&   *(s+1) == ' ')
  521.       {
  522.       for (pc=s;  *pc;  pc++)    *pc = *(pc+1);
  523.  
  524.       }
  525.     else s++;
  526.  
  527.     }
  528.  }
  529. /*
  530. * CleanEnd()
  531. *
  532. * This function cleans up a message trailer for later display via Continue or
  533. * .EH.  Inspired by Glen Heinz (MacCitadel).
  534. */
  535. char *CleanEnd(char *text)
  536.   {
  537.   char *ptr;
  538.   int  wc, lc;  /* Word Count and Letter Count */
  539.   if (strLen(text) == 0) return text;
  540.   ptr = lbyte(text) - 1;      /* End of text of msg */
  541.   /*
  542.   * Strip trailing whitespace.  We structure the loop this
  543.   * way to avoid any chance of accidentally accessing memory outside
  544.   * of the memory area.
  545.   */
  546.   while (ptr != text - 1)
  547.     {
  548.     if (!(*ptr == ' ' || *ptr == NEWLINE || *ptr == TAB)) break;
  549.     ptr--;
  550.  
  551.     }
  552.   ptr++;        /* point at byte following last significant character */
  553.   *ptr = 0;     /* tie it off with a NULL */
  554.   /* Now we want to find a "preferred place" */
  555.   for (wc = lc = 0, ptr--; wc < 4 && ptr > text && lc < 35; ptr--, lc++)
  556.     {
  557.     if (*ptr == ' ') wc++;
  558.     if (*ptr == NEWLINE) break;     /* can't go beyond embedded NEWLINE */
  559.  
  560.     }
  561.   if (ptr == text) return ptr;  /* if msg is empty or < 35 chars long */
  562.   /* else */       return (ptr + 1);    /* else return "favored" spot */
  563.  
  564.   }
  565.